package 炫彩绘制类

import (
	objectbase "gitee.com/go_888/xcgui/xcgui/objectbase"
	xc "gitee.com/go_888/xcgui/xcgui/xc"
	xcc "gitee.com/go_888/xcgui/xcgui/xcc"
)

// X结构_绘制 图形绘制.
type X结构_绘制 struct {
	objectbase.X结构_对象基类
}

// New 绘制_创建, 创建图形绘制模块实例, 返回句柄.
//
// hWindow: 窗口句柄.
func X创建(窗口句柄 int) *X结构_绘制 {
	p := &X结构_绘制{}
	p.X设置句柄(xc.X绘制_创建(窗口句柄))
	return p
}

// NewGDI 绘制_创建GDI, 创建图形绘制模块实例, 返回图形绘制模块实例句柄.
//
// hWindow: 窗口句柄.
//
// hdc: hdc句柄.
func X创建GDI(窗口句柄 int, hdc句柄 uintptr) *X结构_绘制 {
	p := &X结构_绘制{}
	p.X设置句柄(xc.X绘制_创建GDI(窗口句柄, hdc句柄))
	return p
}

// NewByHandle 从图形绘制模块实例句柄创建对象.
func X创建并按图形绘制模块句柄(句柄 int) *X结构_绘制 {
	p := &X结构_绘制{}
	p.X设置句柄(句柄)
	return p
}

// 绘制_销毁, 销毁图形绘制模块实例句柄.
func (d *X结构_绘制) X销毁() *X结构_绘制 {
	xc.X绘制_销毁(d.X句柄)
	return d
}

// 绘制_虚线, 绘制水平或垂直虚线.
//
// x1: 起点x坐标.
//
// y1: 起点y坐标.
//
// x2: 结束点x坐标.
//
// y2: 结束点y坐标.
func (d *X结构_绘制) X虚线(起点x坐标, 起点y坐标, 结束点x坐标, 结束点y坐标 int32) *X结构_绘制 {
	xc.X绘制_虚线(d.X句柄, 起点x坐标, 起点y坐标, 结束点x坐标, 结束点y坐标)
	return d
}

// 绘制_虚线F, 绘制水平或垂直虚线.
//
// x1: 起点x坐标.
//
// y1: 起点y坐标.
//
// x2: 结束点x坐标.
//
// y2: 结束点y坐标.
func (d *X结构_绘制) X虚线F(起点x坐标, 起点y坐标, 结束点x坐标, 结束点y坐标 float32) *X结构_绘制 {
	xc.X绘制_虚线F(d.X句柄, 起点x坐标, 起点y坐标, 结束点x坐标, 结束点y坐标)
	return d
}

// 绘制_圆弧.
//
// x: 坐标.
//
// y: 坐标.
//
// nWidth: 宽度.
//
// nHeight: 高度.
//
// startAngle: 起始角度.
//
// sweepAngle: 绘制角度, 从起始角度开始计算.
func (d *X结构_绘制) X圆弧(x坐标, y坐标, 宽度, 高度 int32, 起始角度 float32, 绘制角度 float32) *X结构_绘制 {
	xc.X绘制_圆弧(d.X句柄, x坐标, y坐标, 宽度, 高度, 起始角度, 绘制角度)
	return d
}

// 绘制_圆弧F.
//
// x: 坐标.
//
// y: 坐标.
//
// nWidth: 宽度.
//
// nHeight: 高度.
//
// startAngle: 起始角度.
//
// sweepAngle: 绘制角度, 从起始角度开始计算.
func (d *X结构_绘制) X圆弧F(x坐标, y坐标, 宽度, 高度, 起始角度, 绘制角度 float32) *X结构_绘制 {
	xc.X绘制_圆弧F(d.X句柄, x坐标, y坐标, 宽度, 高度, 起始角度, 绘制角度)
	return d
}

// 绘制_曲线, D2D暂时留空.
//
// points: 坐标点数组.
//
// count: 数组大小.
//
// tension: 大于或等于0.0F的值，指定曲线的张力, D2D 忽略此参数。.
func (d *X结构_绘制) X曲线(坐标点数组 []xc.X结构_坐标, 数组大小 int32, 曲线张力 float32) *X结构_绘制 {
	xc.X绘制_曲线(d.X句柄, 坐标点数组, 数组大小, 曲线张力)
	return d
}

// 绘制_曲线F, D2D暂时留空.
//
// points: 坐标点数组.
//
// count: 数组大小.
//
// tension: 大于或等于0.0F的值，指定曲线的张力, D2D 忽略此参数。.
func (d *X结构_绘制) X曲线F(坐标点数组 []xc.X结构_坐标F, 数组大小 int32, 曲线张力 float32) *X结构_绘制 {
	xc.X绘制_曲线F(d.X句柄, 坐标点数组, 数组大小, 曲线张力)
	return d
}

// 绘制_线条.
//
// x1: 坐标.
//
// y1: 坐标.
//
// x2: 坐标.
//
// y2: 坐标.
func (d *X结构_绘制) X线条(x1坐标, y1坐标, x2坐标, y2坐标 int32) *X结构_绘制 {
	xc.X绘制_线条(d.X句柄, x1坐标, y1坐标, x2坐标, y2坐标)
	return d
}

// 绘制_线条F.
//
// x1: 坐标.
//
// y1: 坐标.
//
// x2: 坐标.
//
// y2: 坐标.
func (d *X结构_绘制) X线条F(x1坐标, y1坐标, x2坐标, y2坐标 float32) *X结构_绘制 {
	xc.X绘制_线条F(d.X句柄, x1坐标, y1坐标, x2坐标, y2坐标)
	return d
}

// 绘制_多边形, 绘制多边形.
//
// points: 顶点坐标数组.
//
// nCount: 顶点数量.
func (d *X结构_绘制) X多边形(顶点坐标数组 []xc.X结构_坐标, 顶点数量 int32) *X结构_绘制 {
	xc.X绘制_多边形(d.X句柄, 顶点坐标数组, 顶点数量)
	return d
}

// 绘制_多边形F, 绘制多边形.
//
// points: 顶点坐标数组.
//
// nCount: 顶点数量.
func (d *X结构_绘制) X多边形F(顶点坐标数组 []xc.X结构_坐标F, 顶点数量 int32) *X结构_绘制 {
	xc.X绘制_多边形F(d.X句柄, 顶点坐标数组, 顶点数量)
	return d
}

// 绘制_矩形, 绘制矩形边框.
//
// pRect: 矩形坐标 .
func (d *X结构_绘制) X矩形边框(矩形区域 *xc.X结构_矩形) *X结构_绘制 {
	xc.X绘制_矩形边框(d.X句柄, 矩形区域)
	return d
}

// 绘制_矩形F, 绘制矩形边框.
//
// pRect: 矩形坐标 .
func (d *X结构_绘制) X矩形边框F(矩形区域 *xc.X结构_矩形F) *X结构_绘制 {
	xc.X绘制_矩形边框F(d.X句柄, 矩形区域)
	return d
}

// 绘制_置偏移, 设置坐标偏移量, X向左偏移为负数, 向右偏移为正数.
//
// x: X轴偏移量.
//
// y: Y轴偏移量.
func (d *X结构_绘制) X设置偏移(轴偏移量, Y轴偏移量 int32) *X结构_绘制 {
	xc.X绘制_设置偏移(d.X句柄, 轴偏移量, Y轴偏移量)
	return d
}

// 绘制_取偏移, 获取坐标偏移量, X向左偏移为负数, 向右偏移为正数.
//
// pX: 接收X轴偏移量.
//
// pY: 接收Y轴偏移量.
func (d *X结构_绘制) X取偏移(返回X轴偏移量, 返回Y轴偏移量 *int32) *X结构_绘制 {
	xc.X绘制_取偏移(d.X句柄, 返回X轴偏移量, 返回Y轴偏移量)
	return d
}

// 绘制_还原状态, 还原状态, 释放用户绑定的GDI对象, 例如画刷, 画笔.
func (d *X结构_绘制) X还原状态() *X结构_绘制 {
	xc.X绘制_还原状态(d.X句柄)
	return d
}

// 绘制_取HDC, 获取绑定的设备上下文HDC, 返回HDC句柄.
func (d *X结构_绘制) X取HDC() uintptr {
	return xc.X绘制_取HDC(d.X句柄)
}

// 绘制_置画刷颜色, 设置画刷颜色.
//
// color: xc.RGBA 颜色值.
func (d *X结构_绘制) X设置画刷颜色(ABGR int) *X结构_绘制 {
	xc.X绘制_设置画刷颜色(d.X句柄, ABGR)
	return d
}

// 绘制_置文本垂直, 设置文本垂直显示.
//
// bVertical: 是否垂直显示文本.
func (d *X结构_绘制) X设置文本垂直(垂直显示 bool) *X结构_绘制 {
	xc.X绘制_设置文本垂直(d.X句柄, 垂直显示)
	return d
}

// 绘制_置文本对齐, 设置文本对齐.
//
// nFlags: 对齐标识, TextFormatFlag_, TextAlignFlag_, TextTrimming_.
func (d *X结构_绘制) X设置文本对齐(对齐标识 xcc.X文本对齐) *X结构_绘制 {
	xc.X绘制_设置文本对齐(d.X句柄, 对齐标识)
	return d
}

// 绘制_置字体.
//
// hFontx: 炫彩字体.
func (d *X结构_绘制) X设置字体(炫彩字体 int) *X结构_绘制 {
	xc.X绘制_设置字体(d.X句柄, 炫彩字体)
	return d
}

// 绘制_置线宽.
//
// nWidth: 宽度.
func (d *X结构_绘制) X设置线宽(宽度 int32) *X结构_绘制 {
	xc.X绘制_设置线宽(d.X句柄, 宽度)
	return d
}

// 绘制_置线宽F.
//
// nWidth: 宽度.
func (d *X结构_绘制) X设置线宽F(宽度 float32) *X结构_绘制 {
	xc.X绘制_设置线宽F(d.X句柄, 宽度)
	return d
}

// 绘制_置背景模式, SetBkMode() 参见MSDN.
//
// bTransparent: 参见MSDN.
func (d *X结构_绘制) X设置背景模式(参见MSDN bool) *X结构_绘制 {
	xc.X绘制_设置背景模式(d.X句柄, 参见MSDN)
	return d
}

// 绘制_置裁剪区域, 设置裁剪区域.
//
// pRect: 区域坐标.
func (d *X结构_绘制) X设置裁剪区域(矩形区域 *xc.X结构_矩形) *X结构_绘制 {
	xc.X绘制_设置裁剪区域(d.X句柄, 矩形区域)
	return d
}

// 绘制_置D2D文本渲染模式.
//
// mode	渲染模式 XC_DWRITE_RENDERING_MODE_.
func (d *X结构_绘制) X设置D2D文本渲染模式(渲染模式 xcc.D2D文本渲染模式) *X结构_绘制 {
	xc.X绘制_设置D2D文本渲染模式(d.X句柄, 渲染模式)
	return d
}

// 绘制_清除裁剪区域.
func (d *X结构_绘制) X清除裁剪区域() *X结构_绘制 {
	xc.X绘制_清除裁剪区域(d.X句柄)
	return d
}

// 绘制_启用平滑模式.
//
// bEnable: 是否启用.
func (d *X结构_绘制) X启用平滑模式(是否启用 bool) *X结构_绘制 {
	xc.X绘制_启用平滑模式(d.X句柄, 是否启用)
	return d
}

// 绘制_启用窗口透明判断, 当启用之后, 调用GDI+函数时, 如果参数alpha=255, 将自动修改为254, 应对GDI+的bug, 否则透明通道异常.
//
// bTransparent: 是否启用.
func (d *X结构_绘制) X启用窗口透明判断(是否启用 bool) *X结构_绘制 {
	xc.X绘制_启用窗口透明判断(d.X句柄, 是否启用)
	return d
}

// 绘制_创建实心画刷, GDI创建具有指定的纯色逻辑刷.
//
// crColor: 画刷颜色.
func (d *X结构_绘制) X创建实心画刷(画刷颜色 int) uintptr {
	return xc.X绘制_创建实心画刷(d.X句柄, 画刷颜色)
}

// 绘制_创建画笔, GDI创建一个逻辑笔, 指定的样式, 宽度和颜色, 随后的笔可以选择到设备上下文, 用于绘制线条和曲线.
//
// fnPenStyle: 画笔样式, PS_SOLID:实线, PS_DASH:段线, PS_DOT:点线, PS_DASHDOT:段线_点线, PS_DASHDOTDOT:段线_点_点, PS_NULL:空, PS_INSIDEFRAME:实线_笔宽是向里扩展.
//
// nWidth: 画笔宽度.
//
// crColor: xc.RGBA 颜色.
func (d *X结构_绘制) X创建画笔(画笔样式, 画笔宽度 int32, ABGR颜色 int) uintptr {
	return xc.X绘制_创建画笔(d.X句柄, 画笔样式, 画笔宽度, ABGR颜色)
}

// 绘制_创建矩形区域, GDI创建矩形区域, 成功返回区域句柄, 失败返回NULL.
//
// nLeftRect: 左上角X坐标.
//
// nTopRect: 左上角Y坐标.
//
// nRightRect: 右下角X坐标.
//
// nBottomRect: 右下角Y坐标.
func (d *X结构_绘制) X创建矩形区域(左上角X坐标, 左上角Y坐标, 右下角X坐标, 右下角Y坐标 int32) uintptr {
	return xc.X绘制_创建矩形区域(d.X句柄, 左上角X坐标, 左上角Y坐标, 右下角X坐标, 右下角Y坐标)
}

// 绘制_创建圆角矩形区域, GDI创建一个圆角的矩形区域, 成功返回区域句柄, 失败返回NULL.
//
// nLeftRect: X-坐标的左上角.
//
// nTopRect: Y-坐标左上角坐标.
//
// nRightRect: X-坐标右下角.
//
// nBottomRect: Y-坐标右下角.
//
// nWidthEllipse: 椭圆的宽度.
//
// nHeightEllipse: 椭圆的高度.
func (d *X结构_绘制) X创建圆角矩形区域(坐标左上角, Y坐标左上角, 坐标右下角, Y坐标右下角, 椭圆的宽度, 椭圆的高度 int32) uintptr {
	return xc.X绘制_创建圆角矩形区域(d.X句柄, 坐标左上角, Y坐标左上角, 坐标右下角, Y坐标右下角, 椭圆的宽度, 椭圆的高度)
}

// 绘制_创建多边形区域, GDI创建一个多边形区域, 成功返回区域句柄, 失败返回NULL.
//
// pPt: POINT数组.
//
// cPoints: 数组大小.
//
// fnPolyFillMode: 多边形填充模式, 指定用于确定在该地区的像素填充模式,这个参数可以是下列值之一.
//
// ALTERNATE Selects alternate mode (fills area between odd-numbered and even-numbered polygon sides on each scan line).
//
// WINDING Selects winding mode (fills any region with a nonzero winding value).
func (d *X结构_绘制) X创建多边形区域(POINT数组 []xc.X结构_坐标, 数组大小, 多边形填充模式 int32) uintptr {
	return xc.X绘制_创建多边形区域(d.X句柄, POINT数组, 数组大小, 多边形填充模式)
}

// 绘制_GDI_椭圆.
//
// pRect: 矩形区域.
func (d *X结构_绘制) GDI椭圆(矩形区域 *xc.X结构_矩形) bool {
	return xc.X绘制_GDI_椭圆(d.X句柄, 矩形区域)
}

// 绘制_选择裁剪区域, 选择一个区域作为当前裁剪区域, 注意: 该函数只对GDI有效.
//
// hRgn: 区域句柄.
//
// 返回: 返回值指定地区的复杂性，可以是下列值之一.
//
// NULLREGION Region is empty.
//
// SIMPLEREGION Region is a single rectangle.
//
// COMPLEXREGION Region is more than one rectangle.
//
// ERROR An error occurred. (The previous clipping region is unaffected).
func (d *X结构_绘制) X选择裁剪区域(区域句柄 uintptr) *X结构_绘制 {
	xc.X绘制_选择裁剪区域(d.X句柄, 区域句柄)
	return d
}

// 绘制_填充矩形, 通过使用指定的刷子填充一个矩形, 此功能包括左侧和顶部的边界, 但不包括矩形的右边和底部边界.
//
// pRect: 矩形区域.
func (d *X结构_绘制) X填充矩形(矩形区域 *xc.X结构_矩形) *X结构_绘制 {
	xc.X绘制_填充矩形(d.X句柄, 矩形区域)
	return d
}

// 绘制_填充矩形F, 通过使用指定的刷子填充一个矩形, 此功能包括左侧和顶部的边界, 但不包括矩形的右边和底部边界.
//
// pRect: 矩形区域.
func (d *X结构_绘制) X填充矩形F(矩形区域 *xc.X结构_矩形F) *X结构_绘制 {
	xc.X绘制_填充矩形F(d.X句柄, 矩形区域)
	return d
}

// 绘制_填充矩形指定颜色.
//
// pRect: 矩形区域.
//
// color: xc.RGBA 颜色.
func (d *X结构_绘制) X填充矩形指定颜色(矩形区域 *xc.X结构_矩形, 颜色 int) *X结构_绘制 {
	xc.X绘制_填充矩形指定颜色(d.X句柄, 矩形区域, 颜色)
	return d
}

// 绘制_填充矩形指定颜色F.
//
// pRect: 矩形区域.
//
// color: xc.RGBA 颜色.
func (d *X结构_绘制) X填充矩形指定颜色F(矩形区域 *xc.X结构_矩形F, 颜色 int) *X结构_绘制 {
	xc.X绘制_填充矩形指定颜色F(d.X句柄, 矩形区域, 颜色)
	return d
}

// 绘制_填充区域, 通过使用指定的画刷填充一个区域.
//
// hrgn: 区域句柄.
//
// hbr: 画刷句柄.
func (d *X结构_绘制) X填充区域(区域句柄, 画刷句柄 uintptr) bool {
	return xc.X绘制_填充区域(d.X句柄, 区域句柄, 画刷句柄)
}

// 绘制_填充圆形.
//
// pRect: 矩形区域.
func (d *X结构_绘制) X填充圆形(矩形区域 *xc.X结构_矩形) *X结构_绘制 {
	xc.X绘制_填充圆形(d.X句柄, 矩形区域)
	return d
}

// 绘制_填充圆形F.
//
// pRect: 矩形区域.
func (d *X结构_绘制) X填充圆形F(矩形区域 *xc.X结构_矩形F) *X结构_绘制 {
	xc.X绘制_填充圆形F(d.X句柄, 矩形区域)
	return d
}

// 绘制_圆形, 绘制圆边框.
//
// pRect: 矩形区域.
func (d *X结构_绘制) X圆形(矩形区域 *xc.X结构_矩形) *X结构_绘制 {
	xc.X绘制_圆形(d.X句柄, 矩形区域)
	return d
}

// 绘制_填充圆角矩形.
//
// pRect: 矩形坐标.
//
// nWidth: 圆角宽度.
//
// nHeight: 圆角高度.
func (d *X结构_绘制) X填充圆角矩形(矩形区域 *xc.X结构_矩形, 圆角宽度, 圆角高度 int32) *X结构_绘制 {
	xc.X绘制_填充圆角矩形(d.X句柄, 矩形区域, 圆角宽度, 圆角高度)
	return d
}

// 绘制_填充圆角矩形F.
//
// pRect: 矩形坐标.
//
// nWidth: 圆角宽度.
//
// nHeight: 圆角高度.
func (d *X结构_绘制) X填充圆角矩形F(矩形区域 *xc.X结构_矩形F, 圆角宽度, 圆角高度 float32) *X结构_绘制 {
	xc.X绘制_填充圆角矩形F(d.X句柄, 矩形区域, 圆角宽度, 圆角高度)
	return d
}

// 绘制_圆角矩形, 绘制圆角矩形边框.
//
// pRect: 矩形坐标.
//
// nWidth: 圆角宽度.
//
// nHeight: 圆角高度.
func (d *X结构_绘制) X圆角矩形(矩形区域 *xc.X结构_矩形, 圆角宽度, 圆角高度 int32) *X结构_绘制 {
	xc.X绘制_圆角矩形(d.X句柄, 矩形区域, 圆角宽度, 圆角高度)
	return d
}

// 绘制_圆角矩形F, 绘制圆角矩形边框.
//
// pRect: 矩形坐标.
//
// nWidth: 圆角宽度.
//
// nHeight: 圆角高度.
func (d *X结构_绘制) X圆角矩形F(矩形区域 *xc.X结构_矩形, 圆角宽度, 圆角高度 float32) *X结构_绘制 {
	xc.X绘制_圆角矩形F(d.X句柄, 矩形区域, 圆角宽度, 圆角高度)
	return d
}

// 绘制_填充圆角矩形扩展.
//
// pRect: 坐标.
//
// nLeftTop: 圆角大小.
//
// nRightTop: 圆角大小.
//
// nRightBottom: 圆角大小.
//
// nLeftBottom: 圆角大小.
func (d *X结构_绘制) X填充圆角矩形EX(矩形 *xc.X结构_矩形, 圆角大小_左上, 圆角大小_右上, 圆角大小_右下, 圆角大小_左下 int32) *X结构_绘制 {
	xc.X绘制_填充圆角矩形EX(d.X句柄, 矩形, 圆角大小_左上, 圆角大小_右上, 圆角大小_右下, 圆角大小_左下)
	return d
}

// 绘制_填充圆角矩形扩展F.
//
// pRect: 坐标.
//
// nLeftTop: 圆角大小.
//
// nRightTop: 圆角大小.
//
// nRightBottom: 圆角大小.
//
// nLeftBottom: 圆角大小.
func (d *X结构_绘制) X填充圆角矩形EXF(矩形 *xc.X结构_矩形F, 圆角大小_左上, 圆角大小_右上, 圆角大小_右下, 圆角大小_左下 float32) *X结构_绘制 {
	xc.X绘制_填充圆角矩形EXF(d.X句柄, 矩形, 圆角大小_左上, 圆角大小_右上, 圆角大小_右下, 圆角大小_左下)
	return d
}

// 绘制_圆角矩形扩展, 绘制圆角矩形边框.
//
// pRect: 坐标.
//
// nLeftTop: 圆角大小.
//
// nRightTop: 圆角大小.
//
// nRightBottom: 圆角大小.
//
// nLeftBottom: 圆角大小.
func (d *X结构_绘制) X圆角矩形EX(矩形 *xc.X结构_矩形, 圆角大小_左上, 圆角大小_右上, 圆角大小_右下, 圆角大小_左下 int32) *X结构_绘制 {
	xc.X绘制_圆角矩形EX(d.X句柄, 矩形, 圆角大小_左上, 圆角大小_右上, 圆角大小_右下, 圆角大小_左下)
	return d
}

// 绘制_圆角矩形扩展F, 绘制圆角矩形边框.
//
// pRect: 坐标.
//
// nLeftTop: 圆角大小.
//
// nRightTop: 圆角大小.
//
// nRightBottom: 圆角大小.
//
// nLeftBottom: 圆角大小.
func (d *X结构_绘制) X圆角矩形EXF(矩形 *xc.X结构_矩形, 圆角大小_左上, 圆角大小_右上, 圆角大小_右下, 圆角大小_左下 float32) *X结构_绘制 {
	xc.X绘制_圆角矩形EXF(d.X句柄, 矩形, 圆角大小_左上, 圆角大小_右上, 圆角大小_右下, 圆角大小_左下)
	return d
}

// 绘制_矩形, 绘制矩形, 使用当前的画刷和画笔. 如果函数成功, 返回非零值, 如果函数失败, 返回值是零.
//
// nLeftRect: 左上角X坐标.
//
// nTopRect: 左上角Y坐标.
//
// nRightRect: 右下角X坐标.
//
// nBottomRect: 右下角Y坐标.
func (d *X结构_绘制) X矩形(左上角X坐标, 左上角Y坐标, 右下角X坐标, 右下角Y坐标 int32) bool {
	return xc.X绘制_矩形(d.X句柄, 左上角X坐标, 左上角Y坐标, 右下角X坐标, 右下角Y坐标)
}

// 绘制_渐变填充2, 渐变填充, 从一种颜色过渡到另一种颜色.
//
// pRect: 矩形坐标.
//
// color1: 开始颜色, xc.RGBA 颜色.
//
// color2: 结束颜色, xc.RGBA 颜色.
//
// mode: 模式, GRADIENT_FILL_.
func (d *X结构_绘制) X渐变填充2(矩形区域 *xc.X结构_矩形, 开始颜色 int, 结束颜色 int, 模式 xcc.X渐变填充模式) *X结构_绘制 {
	xc.X绘制_渐变填充2(d.X句柄, 矩形区域, 开始颜色, 结束颜色, 模式)
	return d
}

// 绘制_渐变填充2F, 渐变填充, 从一种颜色过渡到另一种颜色.
//
// pRect: 矩形坐标.
//
// color1: 开始颜色, xc.RGBA 颜色.
//
// color2: 结束颜色, xc.RGBA 颜色.
//
// mode: 模式, GRADIENT_FILL_.
func (d *X结构_绘制) X渐变填充2F(矩形区域 *xc.X结构_矩形F, 开始颜色 int, 结束颜色 int, 模式 xcc.X渐变填充模式) *X结构_绘制 {
	xc.X绘制_渐变填充2F(d.X句柄, 矩形区域, 开始颜色, 结束颜色, 模式)
	return d
}

// 绘制_渐变填充4, 渐变填充,从一种颜色过渡到另一种颜色.
//
// pRect: 矩形坐标.
//
// color1: 开始颜色, xc.RGBA 颜色.
//
// color2: 结束颜色, xc.RGBA 颜色.
//
// color3: 开始颜色, xc.RGBA 颜色.
//
// color4: 结束颜色, xc.RGBA 颜色.
//
// mode: 模式, GRADIENT_FILL_.
func (d *X结构_绘制) X渐变填充4(矩形区域 *xc.X结构_矩形, 开始颜色 int, 结束颜色_中间 int, 开始颜色_中间 int, 结束颜色 int, 模式 xcc.X渐变填充模式) *X结构_绘制 {
	xc.X绘制_渐变填充4(d.X句柄, 矩形区域, 开始颜色, 结束颜色_中间, 开始颜色_中间, 结束颜色, 模式)
	return d
}

// 绘制_渐变填充4F, 渐变填充,从一种颜色过渡到另一种颜色.
//
// pRect: 矩形坐标.
//
// color1: 开始颜色, xc.RGBA 颜色.
//
// color2: 结束颜色, xc.RGBA 颜色.
//
// color3: 开始颜色, xc.RGBA 颜色.
//
// color4: 结束颜色, xc.RGBA 颜色.
//
// mode: 模式, GRADIENT_FILL_.
func (d *X结构_绘制) X渐变填充4F(矩形区域 *xc.X结构_矩形F, 开始颜色 int, 结束颜色_中间 int, 开始颜色_中间 int, 结束颜色 int, 模式 xcc.X渐变填充模式) *X结构_绘制 {
	xc.X绘制_渐变填充4F(d.X句柄, 矩形区域, 开始颜色, 结束颜色_中间, 开始颜色_中间, 结束颜色, 模式)
	return d
}

// 绘制_边框区域, 绘制边框, 使用指定的画刷绘制指定的区域的边框. 如果函数成功, 返回非零值, 如果函数失败, 返回值是零.
//
// hrgn: 区域句柄.
//
// hbr: 画刷句柄.
//
// nWidth: 边框宽度, 垂直边.
//
// nHeight: 边框高度, 水平边.
func (d *X结构_绘制) X边框区域(区域句柄, 画刷句柄 uintptr, 边框宽度, 边框高度 int32) bool {
	return xc.X绘制_边框区域(d.X句柄, 区域句柄, 画刷句柄, 边框宽度, 边框高度)
}

// 绘制_焦点矩形.
//
// pRect: 矩形坐标.
func (d *X结构_绘制) X焦点矩形(矩形区域 *xc.X结构_矩形) *X结构_绘制 {
	xc.X绘制_焦点矩形(d.X句柄, 矩形区域)
	return d
}

// 绘制_焦点矩形F.
//
// pRect: 矩形坐标.
func (d *X结构_绘制) X焦点矩形F(矩形区域 *xc.X结构_矩形F) *X结构_绘制 {
	xc.X绘制_焦点矩形F(d.X句柄, 矩形区域)
	return d
}

// 绘制_移动到起点, 更新当前位置到指定点，并返回以前的位置. 如果函数成功, 返回非零值.
//
// X: 坐标.
//
// Y: 坐标.
//
// pPoint: 接收以前的当前位置到一个POINT结构的指针, 如果这个参数是NULL指针, 没有返回原来的位置.
func (d *X结构_绘制) X移动到起点(坐标x, 坐标y int32, 返回原位置 *xc.X结构_坐标) bool {
	return xc.X绘制_移动到起点(d.X句柄, 坐标x, 坐标y, 返回原位置)
}

// 绘制_线终点, 函数绘制一条线从当前位置到, 但不包括指定点. 如果函数成功, 返回非零值.
//
// nXEnd: X坐标, 线结束点.
//
// nYEnd: Y坐标, 线结束点.
func (d *X结构_绘制) X线终点(坐标, Y坐标 int32) bool {
	return xc.X绘制_线终点(d.X句柄, 坐标, Y坐标)
}

// 绘制_折线, Polyline() 参见MSDN.
//
// pArrayPt: 参见MSDN.
//
// arrayPtSize: 参见MSDN.
func (d *X结构_绘制) X折线(pArrayPt []xc.X结构_坐标, arrayPtSize int32) bool {
	return xc.X绘制_折线(d.X句柄, pArrayPt, arrayPtSize)
}

// 绘制_置像素颜色, 函数设置在指定的坐标到指定的颜色的像素. 如果函数成功返回RGB值, 如果失败返回-1.
//
// X: 坐标.
//
// Y: 坐标.
//
// crColor: RGB颜色值.
func (d *X结构_绘制) X设置像素颜色(坐标x, 坐标y int32, RGB颜色值 int) int {
	return xc.X绘制_设置像素颜色(d.X句柄, 坐标x, 坐标y, RGB颜色值)
}

// 绘制_取D2D渲染目标, 返回 *ID2D1RenderTarget.
func (d *X结构_绘制) X取D2D渲染目标() int {
	return xc.X绘制_取D2D渲染目标(d.X句柄)
}

// 绘制_图标, 绘制图标, DrawIconEx()参见MSDN.
//
// xLeft: .
//
// yTop: .
//
// hIcon: .
//
// cxWidth: .
//
// cyWidth: .
//
// istepIfAniCur: .
//
// hbrFlickerFreeDraw: .
//
// diFlags: .
func (d *X结构_绘制) X图标(xLeft, yTop int32, hIcon uintptr, cxWidth, cyWidth int32, istepIfAniCur uint32, hbrFlickerFreeDraw uintptr, diFlags uint32) bool {
	return xc.X绘制_图标(d.X句柄, xLeft, yTop, hIcon, cxWidth, cyWidth, istepIfAniCur, hbrFlickerFreeDraw, diFlags)
}

// 绘制_复制, BitBlt() 参见MSDN.
//
// nXDest: XX.
//
// nYDest: XX.
//
// nWidth: XX.
//
// nHeight: XX.
//
// hdcSrc: XX.
//
// nXSrc: XX.
//
// nYSrc: XX.
//
// dwRop: XX.
func (d *X结构_绘制) X复制(nXDest, nYDest, nWidth, nHeight int32, hdcSrc uintptr, nXSrc, nYSrc int32, dwRop uint32) bool {
	return xc.X绘制_复制(d.X句柄, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc, dwRop)
}

// 绘制_复制2, BitBlt() 参见MSDN.
//
// nXDest: XX.
//
// nYDest: XX.
//
// nWidth: XX.
//
// nHeight: XX.
//
// hDrawSrc: XX.
//
// nXSrc: XX.
//
// nYSrc: XX.
//
// dwRop: XX.
func (d *X结构_绘制) X复制2(nXDest, nYDest, nWidth, nHeight int32, hDrawSrc uintptr, nXSrc, nYSrc int32, dwRop uint32) bool {
	return xc.X绘制_复制2(d.X句柄, nXDest, nYDest, nWidth, nHeight, hDrawSrc, nXSrc, nYSrc, dwRop)
}

// 绘制_带透明复制, AlphaBlend() 参见MSDN.
//
// nXOriginDest: XX.
//
// nYOriginDest: XX.
//
// nWidthDest: XX.
//
// nHeightDest: XX.
//
// hdcSrc: XX.
//
// nXOriginSrc: XX.
//
// nYOriginSrc: XX.
//
// nWidthSrc: XX.
//
// nHeightSrc: XX.
//
// alpha: XX.
func (d *X结构_绘制) X带透明复制(nXOriginDest, nYOriginDest, nWidthDest, nHeightDest int32, hdcSrc uintptr, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, alpha int32) bool {
	return xc.X绘制_带透明复制(d.X句柄, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, hdcSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, alpha)
}

// 绘制_填充多边形, 填充多边形.
//
// points: 顶点坐标数组.
//
// nCount: 顶点数量.
func (d *X结构_绘制) X填充多边形(顶点坐标数组 []xc.X结构_坐标, 顶点数量 int32) *X结构_绘制 {
	xc.X绘制_填充多边形(d.X句柄, 顶点坐标数组, 顶点数量)
	return d
}

// 绘制_填充多边形F, 填充多边形.
//
// points: 顶点坐标数组.
//
// nCount: 顶点数量.
func (d *X结构_绘制) X填充多边形F(顶点坐标数组 []xc.X结构_坐标F, 顶点数量 int32) *X结构_绘制 {
	xc.X绘制_填充多边形F(d.X句柄, 顶点坐标数组, 顶点数量)
	return d
}

// 绘制_图片.
//
// hImageFrame: 图片句柄.
//
// x: x坐标.
//
// y: y坐标.
func (d *X结构_绘制) X图片(图片句柄 int, x坐标, y坐标 int32) {
	xc.X绘制_图片(d.X句柄, 图片句柄, x坐标, y坐标)
}

// 绘制_图片F.
//
// hImageFrame: 图片句柄.
//
// x: x坐标.
//
// y: y坐标.
func (d *X结构_绘制) X图片F(图片句柄 int, x坐标, y坐标 float32) *X结构_绘制 {
	xc.X绘制_图片F(d.X句柄, 图片句柄, x坐标, y坐标)
	return d
}

// 绘制_图片自适应.
//
// hImageFrame: 图片句柄.
//
// pRect: 坐标.
//
// bOnlyBorder: 是否只绘制边缘区域.
func (d *X结构_绘制) X图片自适应(图片句柄 int, 矩形 *xc.X结构_矩形, 只绘制边缘区域 bool) *X结构_绘制 {
	xc.X绘制_图片自适应(d.X句柄, 图片句柄, 矩形, 只绘制边缘区域)
	return d
}

// 绘制_图片自适应F.
//
// hImageFrame: 图片句柄.
//
// pRect: 坐标.
//
// bOnlyBorder: 是否只绘制边缘区域.
func (d *X结构_绘制) X图片自适应F(图片句柄 int, 矩形 *xc.X结构_矩形F, 只绘制边缘区域 bool) *X结构_绘制 {
	xc.X绘制_图片自适应F(d.X句柄, 图片句柄, 矩形, 只绘制边缘区域)
	return d
}

// 绘制_图片扩展, 绘制图片.
//
// hImageFrame: 图片句柄.
//
// x: x坐标.
//
// y: y坐标.
//
// width: 宽度.
//
// height: 高度.
func (d *X结构_绘制) X图片EX(图片句柄 int, x坐标, y坐标, 宽度, 高度 int32) *X结构_绘制 {
	xc.X绘制_图片EX(d.X句柄, 图片句柄, x坐标, y坐标, 宽度, 高度)
	return d
}

// 绘制_图片扩展F, 绘制图片.
//
// hImageFrame: 图片句柄.
//
// x: x坐标.
//
// y: y坐标.
//
// width: 宽度.
//
// height: 高度.
func (d *X结构_绘制) X图片EXF(图片句柄 int, x坐标, y坐标, 宽度, 高度 float32) *X结构_绘制 {
	xc.X绘制_图片EXF(d.X句柄, 图片句柄, x坐标, y坐标, 宽度, 高度)
	return d
}

// 绘制_图片增强.
//
// hImageFrame: 图片句柄.
//
// pRect: 坐标.
//
// bClip: 是否裁剪区域.
func (d *X结构_绘制) X图片增强(图片句柄 int, 矩形 *xc.X结构_矩形, 是否裁剪区域 bool) *X结构_绘制 {
	xc.X绘制_图片增强(d.X句柄, 图片句柄, 矩形, 是否裁剪区域)
	return d
}

// 绘制_图片增强F.
//
// hImageFrame: 图片句柄.
//
// pRect: 坐标.
//
// bClip: 是否裁剪区域.
func (d *X结构_绘制) X图片增强F(图片句柄 int, 矩形 *xc.X结构_矩形F, 是否裁剪区域 bool) *X结构_绘制 {
	xc.X绘制_图片增强F(d.X句柄, 图片句柄, 矩形, 是否裁剪区域)
	return d
}

// 绘制_图片增强扩展.
//
// hImageFrame: 图片句柄.
//
// prcDest: 目标坐标.
//
// prcSrc: 源坐标.
func (d *X结构_绘制) X图片增强扩展(图片句柄 int, 目标坐标 *xc.X结构_矩形, 源坐标 *xc.X结构_矩形) *X结构_绘制 {
	xc.X绘制_图片增强EX(d.X句柄, 图片句柄, 目标坐标, 源坐标)
	return d
}

// 绘制_图片增强扩展F.
//
// hImageFrame: 图片句柄.
//
// prcDest: 目标坐标.
//
// prcSrc: 源坐标.
func (d *X结构_绘制) X图片增强EXF(图片句柄 int, 目标坐标 *xc.X结构_矩形F, 源坐标 *xc.X结构_矩形) *X结构_绘制 {
	xc.X绘制_图片增强EXF(d.X句柄, 图片句柄, 目标坐标, 源坐标)
	return d
}

// 绘制_图片增强遮盖, 绘制带遮盖的图片. D2D留空.
//
// hImageFrame: 图片句柄.
//
// hImageFrameMask: 图片句柄, 遮盖.
//
// pRect: 坐标.
//
// pRectMask: 坐标, 遮盖.
//
// bClip: 是否裁剪区域.
func (d *X结构_绘制) X图片增强遮盖(图片句柄 int, 图片遮盖句柄 int, 矩形 *xc.X结构_矩形, 坐标_遮盖 *xc.X结构_矩形, 是否裁剪区域 bool) *X结构_绘制 {
	xc.X绘制_图片增强遮盖(d.X句柄, 图片句柄, 图片遮盖句柄, 矩形, 坐标_遮盖, 是否裁剪区域)
	return d
}

// 绘制_图片平铺, 绘制图片.
//
// hImageFrame: 图片句柄.
//
// pRect: 坐标.
//
// flag: 标识, 0:从左上角开始平铺, 1:从左下角开始平铺.
func (d *X结构_绘制) X图片平铺(图片句柄 int, 图片遮盖句柄 int, 矩形 *xc.X结构_矩形, 标识 int32) *X结构_绘制 {
	xc.X绘制_图片平铺(d.X句柄, 图片句柄, 图片遮盖句柄, 矩形, 标识)
	return d
}

// 绘制_图片平铺F, 绘制图片.
//
// hImageFrame: 图片句柄.
//
// pRect: 坐标.
//
// flag: 标识, 0:从左上角开始平铺, 1:从左下角开始平铺.
func (d *X结构_绘制) X图片平铺F(图片句柄 int, 图片遮盖句柄 int, 矩形 *xc.X结构_矩形F, 标识 int32) *X结构_绘制 {
	xc.X绘制_图片平铺F(d.X句柄, 图片句柄, 图片遮盖句柄, 矩形, 标识)
	return d
}

// 绘制_图片遮盖, 绘制带遮盖的图片, D2D留空.
//
// hImageFrame: 图片句柄.
//
// hImageFrameMask: 图片句柄, 遮盖.
//
// pRect: 坐标.
//
// x: 目标X坐标.
//
// y: 目标Y坐标.
func (d *X结构_绘制) X图片遮盖(图片句柄 int, 图片遮盖句柄 int, 矩形 *xc.X结构_矩形, 目标x坐标, 目标y坐标 int32) *X结构_绘制 {
	xc.X绘制_图片遮盖(d.X句柄, 图片句柄, 图片遮盖句柄, 矩形, 目标x坐标, 目标y坐标)
	return d
}

// 绘制_文本指定矩形, X文本指定矩形() 参见MSDN.
//
// lpString: 字符串.
//
// lpRect: 坐标.
func (d *X结构_绘制) X文本指定矩形(文本 string, 坐标 *xc.X结构_矩形) *X结构_绘制 {
	xc.X绘制_文本指定矩形(d.X句柄, 文本, 坐标)
	return d
}

// 绘制_文本指定矩形F, DrawText() 参见MSDN.
//
// lpString: 字符串.
//
// lpRect: 坐标.
func (d *X结构_绘制) X文本指定矩形F(文本 string, 坐标 *xc.X结构_矩形F) *X结构_绘制 {
	xc.X绘制_文本指定矩形F(d.X句柄, 文本, 坐标)
	return d
}

// 绘制_文本下划线.
//
// lpString: 字符串.
//
// lpRect: 坐标.
//
// colorLine: 下划线颜色, xc.RGBA 颜色.
func (d *X结构_绘制) X文本下划线(文本 string, 坐标 *xc.X结构_矩形, 下划线颜色 int) *X结构_绘制 {
	xc.X绘制_文本下划线(d.X句柄, 文本, 坐标, 下划线颜色)
	return d
}

// 绘制_文本下划线F.
//
// lpString: 字符串.
//
// lpRect: 坐标.
//
// colorLine: 下划线颜色, xc.RGBA 颜色.
func (d *X结构_绘制) X文本下划线F(文本 string, 坐标 *xc.X结构_矩形F, 下划线颜色 int) *X结构_绘制 {
	xc.X绘制_文本下划线F(d.X句柄, 文本, 坐标, 下划线颜色)
	return d
}

// 绘制_文本, X文本输出() 参见MSDN.
//
// nXStart: XX.
//
// nYStart: XX.
//
// lpString: XX.
//
// cbString: XX.
func (d *X结构_绘制) X文本输出(nXStart, nYStart int32, lpString string, cbString string) *X结构_绘制 {
	xc.X绘制_文本(d.X句柄, nXStart, nYStart, lpString, cbString)
	return d
}

// 绘制_文本F, TextOut() 参见MSDN.
//
// nXStart: XX.
//
// nYStart: XX.
//
// lpString: XX.
//
// cbString: XX.
func (d *X结构_绘制) X文本输出F(nXStart, nYStart float32, lpString string, cbString string) *X结构_绘制 {
	xc.X绘制_文本F(d.X句柄, nXStart, nYStart, lpString, cbString)
	return d
}

// 绘制_文本扩展, TextOut() 参见MSDN.
//
// nXStart: XX.
//
// nYStart: XX.
//
// lpString: XX.
func (d *X结构_绘制) X文本输出EX(nXStart, nYStart int32, lpString string) *X结构_绘制 {
	xc.X绘制_文本EX(d.X句柄, nXStart, nYStart, lpString)
	return d
}

// 绘制_文本扩展F, TextOut() 参见MSDN.
//
// nXStart: XX.
//
// nYStart: XX.
//
// lpString: XX.
func (d *X结构_绘制) X文本输出EXF(nXStart, nYStart float32, lpString string) *X结构_绘制 {
	xc.X绘制_文本EXF(d.X句柄, nXStart, nYStart, lpString)
	return d
}

// 绘制_文本A, TextOut() 参见MSDN.
//
// nXStart: XX.
//
// nYStart: XX.
//
// lpString: XX.
func (d *X结构_绘制) X文本输出A(nXStart, nYStart int32, lpString string) *X结构_绘制 {
	xc.X绘制_文本A(d.X句柄, nXStart, nYStart, lpString)
	return d
}

// 绘制_文本AF, TextOut() 参见MSDN.
//
// nXStart: XX.
//
// nYStart: XX.
//
// lpString: XX.
func (d *X结构_绘制) X文本输出AF(nXStart, nYStart float32, lpString string) *X结构_绘制 {
	xc.X绘制_文本AF(d.X句柄, nXStart, nYStart, lpString)
	return d
}

// 绘制_设置文本渲染提示.
//
// nType: XX.
func (d *X结构_绘制) X设置文本渲染提示(nType int32) *X结构_绘制 {
	xc.X绘制_设置文本渲染提示(d.X句柄, nType)
	return d
}

// 绘制_SVG源.
//
// hSvg: SVG句柄.
func (d *X结构_绘制) SVG源(SVG句柄 int) *X结构_绘制 {
	xc.X绘制_SVG源(d.X句柄, SVG句柄)
	return d
}

// 绘制_SVG.
//
// hSvg: SVG句柄.
//
// x: x坐标.
//
// y: y坐标.
func (d *X结构_绘制) SVG(SVG句柄 int, x坐标, y坐标 int32) *X结构_绘制 {
	xc.X绘制_SVG(d.X句柄, SVG句柄, x坐标, y坐标)
	return d
}

// 绘制_SVG扩展.
//
// hSvg: SVG句柄.
//
// x: x坐标.
//
// y: y坐标.
//
// nWidth: 宽度.
//
// nHeight: 高度.
func (d *X结构_绘制) SVGEX(SVG句柄 int, x坐标, y坐标, 宽度, 高度 int32) *X结构_绘制 {
	xc.X绘制_SVGEX(d.X句柄, SVG句柄, x坐标, y坐标, 宽度, 高度)
	return d
}

// 绘制_SVG大小.
//
// hSvg: SVG句柄.
//
// nWidth: 宽度.
//
// nHeight: 高度.
func (d *X结构_绘制) SVG大小(SVG句柄 int, 宽度, 高度 int32) *X结构_绘制 {
	xc.X绘制_SVG大小(d.X句柄, SVG句柄, 宽度, 高度)
	return d
}

// 绘制_D2D_清理, 使用指定颜色清理画布.
//
// color: xc.RGBA 颜色值.
func (d *X结构_绘制) D2D清理(ABGR int) *X结构_绘制 {
	xc.X绘制_D2D_清理(d.X句柄, ABGR)
	return d
}

// 绘制_图片遮盖矩形, 使用矩形作为遮罩.
//
// hImageFrame: 图片句柄.
//
// pRect: 矩形坐标.
//
// pRcMask: 遮罩坐标.
//
// pRcRoundAngle: 遮罩圆角.
func (d *X结构_绘制) X图片遮盖矩形(图片句柄 int, 矩形区域 *xc.X结构_矩形, 遮罩坐标 *xc.X结构_矩形, 遮罩圆角 *xc.X结构_矩形) *X结构_绘制 {
	xc.X绘制_图片遮盖矩形(d.X句柄, 图片句柄, 矩形区域, 遮罩坐标, 遮罩圆角)
	return d
}

// 绘制_图片遮盖圆型, 使用圆形作为遮罩.
//
// hImageFrame: 图片句柄.
//
// pRect: 矩形坐标.
//
// pRcMask: 遮罩坐标.
func (d *X结构_绘制) X图片遮盖圆型(图片句柄 int, 矩形区域 *xc.X结构_矩形, 遮罩坐标 *xc.X结构_矩形) *X结构_绘制 {
	xc.X绘制_图片遮盖圆型(d.X句柄, 图片句柄, 矩形区域, 遮罩坐标)
	return d
}

// 绘制_取字体, 返回字体句柄.
func (d *X结构_绘制) X取字体() int {
	return xc.X绘制_取字体(d.X句柄)
}
